④CDATA节

• • 1. 、实验六：为类类型属性赋值

①创建班级类Clazz

public class Clazz {

private Integer clazzId;

private String clazzName;

public Integer getClazzId() { return clazzId;

}

public void setClazzId(Integer clazzId) { this.clazzId = clazzId;

}

public String getClazzName() { return clazzName;

}

public void setClazzName(String clazzName) { this.clazzName = clazzName;

}

@Override

public String toString() { return “Clazz{“ +

“clazzId=” + clazzId +

“, clazzName=’” + clazzName + ‘\‘’ + ‘}‘;

}

public Clazz() {

}

public Clazz(Integer clazzId, String clazzName) { this.clazzId = clazzId;

this.clazzName = clazzName;

}

}

②修改Student类

在Student类中添加以下代码：

private Clazz clazz;

public Clazz getClazz() { return clazz;

}

public void setClazz(Clazz clazz) { this.clazz = clazz;

}

③方式一：引用外部已声明的bean

配置Clazz类型的bean：

为Student中的clazz属性赋值：

错误演示：

如果错把ref属性写成了value属性，会抛出异常： Caused by: java.lang.IllegalStateException:

Cannot convert value of type ‘java.lang.String’ to required type

‘com.atguigu.spring.bean.Clazz’ for property ‘clazz’: no matching editors or conversion strategy found

意思是不能把String类型转换成我们要的Clazz类型，说明我们使用value属性时，Spring只把这个 属性看做一个普通的字符串，不会认为这是一个bean的id，更不会根据它去找到bean来赋值

④方式二：内部bean

③方式三：级联属性赋值

• • 1. 、实验七：为数组类型属性赋值

<!-- 一定先引用某个bean为属性赋值，才可以使用级联方式更新属性 -->

①修改Student类

在Student类中添加以下代码：

private String[] hobbies;

public String[] getHobbies() { return hobbies;

}

public void setHobbies(String[] hobbies) { this.hobbies = hobbies;

}

②配置bean

• • 1. 、实验八：为集合类型属性赋值

①为List集合类型属性赋值

在Clazz类中添加以下代码：

配置bean：

private List students;

public List getStudents() { return students;

}

public void setStudents(List students) { this.students = students;

}

若为Set集合类型属性赋值，只需要将其中的list标签改为set标签即可

②为Map集合类型属性赋值

创建教师类Teacher：

public class Teacher {

private Integer teacherId;

private String teacherName;

public Integer getTeacherId() { return teacherId;

}

public void setTeacherId(Integer teacherId) { this.teacherId = teacherId;

}

public String getTeacherName() { return teacherName;

}

public void setTeacherName(String teacherName) { this.teacherName = teacherName;

}

public Teacher(Integer teacherId, String teacherName) { this.teacherId = teacherId;

this.teacherName = teacherName;

}

在Student类中添加以下代码：

public Teacher() {

}

@Override

public String toString() { return “Teacher{“ +

“teacherId=” + teacherId +

“, teacherName=’” + teacherName + ‘\‘’ + ‘}‘;

}

}

private Map<String, Teacher> teacherMap;

public Map<String, Teacher> getTeacherMap() { return teacherMap;

}

public void setTeacherMap(Map<String, Teacher> teacherMap) { this.teacherMap = teacherMap;

}

配置bean：

<!--list集合类型的bean-->

<util:list id=”students”>

<!--map集合类型的bean-->

<util:map id=”teacherMap”>

@Test

public void testDataSource() throws SQLException {

ApplicationContext ac = new ClassPathXmlApplicationContext(“spring- datasource.xml”);

DataSource dataSource = ac.getBean(DataSource.class); Connection connection = dataSource.getConnection(); System.out.println(connection);

}

• • 1. 、实验十一：bean的作用域

①概念

在Spring中可以通过配置bean标签的scope属性来指定bean的作用域范围，各取值含义参加下表：

取值

含义

创建对象的时机

singleton（默认）

在IOC容器中，这个bean的对象始终为单实例

IOC容器初始化时

prototype

这个bean在IOC容器中有多个实例

获取bean时

如果是在WebApplicationContext环境下还会有另外两个作用域（但不常用）：

取值

含义

request

在一个请求范围内有效

session

在一个会话范围内有效

②创建类User

public class User {

private Integer id;

private String username;

private String password;

private Integer age;

public User() {

}

public User(Integer id, String username, String password, Integer age) { this.id = id;

this.username = username;

this.password = password; this.age = age;

}

public Integer getId() { return id;

}

public void setId(Integer id) { this.id = id;

}

public String getUsername() { return username;

}

public void setUsername(String username) { this.username = username;

}

public String getPassword() { return password;

}

public void setPassword(String password) { this.password = password;

}

public Integer getAge() { return age;

}

public void setAge(Integer age) { this.age = age;

}

@Override

public String toString() { return “User{“ +

“id=” + id +

“, username=’” + username + ‘\‘’ + “, password=’” + password + ‘\‘’ + “, age=” + age +

‘}‘;

}

}

③配置bean

<!-- scope属性：取值singleton（默认值），bean在IOC容器中只有一个实例，IOC容器初始化时创建对象 -->

<!-- scope属性：取值prototype，bean在IOC容器中可以有多个实例，getBean()时创建对象 -->

④测试

• • 1. 、实验十二：bean的生命周期

@Test

public void testBeanScope(){

ApplicationContext ac = new ClassPathXmlApplicationContext(“spring- scope.xml”);

User user1 = ac.getBean(User.class); User user2 = ac.getBean(User.class); System.out.println(user1==user2);

}

①具体的生命周期过程

bean对象创建（调用无参构造器） 给bean对象设置属性

bean对象初始化之前操作（由bean的后置处理器负责） bean对象初始化（需在配置bean时指定初始化方法）

bean对象初始化之后操作（由bean的后置处理器负责） bean对象就绪可以使用

bean对象销毁（需在配置bean时指定销毁方法） IOC容器关闭

②修改类User

public class User {

private Integer id;

private String username;

private String password;

private Integer age;

public User() { System.out.println(“生命周期：1、创建对象”);

}

public User(Integer id, String username, String password, Integer age) { this.id = id;

this.username = username; this.password = password; this.age = age;

}

public Integer getId() { return id;

}

public void setId(Integer id) {

System.out.println(“生命周期：2、依赖注入”); this.id = id;

}

public String getUsername() { return username;

}

public void setUsername(String username) { this.username = username;

}

public String getPassword() { return password;

}

public void setPassword(String password) { this.password = password;

}

public Integer getAge() { return age;

}

public void setAge(Integer age) { this.age = age;

}

public void initMethod(){

System.out.println(“生命周期：3、初始化”);

}

public void destroyMethod(){

System.out.println(“生命周期：5、销毁”);

}

@Override

public String toString() { return “User{“ +

“id=” + id +

“, username=’” + username + ‘\‘’ + “, password=’” + password + ‘\‘’ + “, age=” + age +

‘}‘;

}

}

注意其中的initMethod()和destroyMethod()，可以通过配置bean指定为初始化和销毁的方法

③配置bean

<!-- 使用init-method属性指定初始化方法 -->

<!-- 使用destroy-method属性指定销毁方法 -->

<bean class=”com.atguigu.bean.User” scope=”prototype” init-method=”initMethod” destroy-method=”destroyMethod”>

④测试

⑤bean的后置处理器

@Test

public void testLife(){ ClassPathXmlApplicationContext ac = new

ClassPathXmlApplicationContext(“spring-lifecycle.xml”); User bean = ac.getBean(User.class);

System.out.println(“生命周期：4、通过IOC容器获取bean并使用”);

ac.close();

}

bean的后置处理器会在生命周期的初始化前后添加额外的操作，需要实现BeanPostProcessor接口， 且配置到IOC容器中，需要注意的是，bean后置处理器不是单独针对某一个bean生效，而是针对IOC容器中所有bean都会执行

创建bean的后置处理器：

package com.atguigu.spring.process;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanProcessor implements BeanPostProcessor {

@Override

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

System.out.println(“☆☆☆” + beanName + “ = “ + bean);

return bean;

}

@Override

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

System.out.println(“★★★” + beanName + “ = “ + bean);

return bean;

}

}

在IOC容器中配置后置处理器：

<!-- bean的后置处理器要放入IOC容器才能生效 -->

@Test

public void testAutoWireByXML(){

ApplicationContext ac = new ClassPathXmlApplicationContext(“autowire- xml.xml”);

UserController userController = ac.getBean(UserController.class); userController.saveUser();

}

• 1. 、基于注解管理bean
     1. 、实验一：标记与扫描

①注解

和 XML 配置文件一样，注解本身并不能执行，注解本身仅仅只是做一个标记，具体的功能是框架检测到注解标记的位置，然后针对这个位置按照注解标记的功能来执行具体操作。

本质上：所有一切的操作都是Java代码来完成的，XML和注解只是告诉框架中的Java代码如何执行。

举例：元旦联欢会要布置教室，蓝色的地方贴上元旦快乐四个字，红色的地方贴上拉花，黄色的地方贴 上气球。

班长做了所有标记，同学们来完成具体工作。墙上的标记相当于我们在代码中使用的注解，后面同学们 做的工作，相当于框架的具体操作。

②扫描

Spring 为了知道程序员在哪些地方标记了什么注解，就需要通过扫描的方式，来进行检测。然后根据注解进行后续操作。

③新建Maven Module

④创建Spring配置文件

⑤标识组件的常用注解

@Component：将类标识为普通组件 @Controller：将类标识为控制层组件 @Service：将类标识为业务层组件 @Repository：将类标识为持久层组件

问：以上四个注解有什么关系和区别？

通过查看源码我们得知，@Controller、@Service、@Repository这三个注解只是在@Component注解 的基础上起了三个新的名字。

对于Spring使用IOC容器管理这些组件来说没有区别。所以@Controller、@Service、@Repository这三个注解只是给开发人员看的，让我们能够便于分辨组件的作用。

注意：虽然它们本质上一样，但是为了代码的可读性，为了程序结构严谨我们肯定不能随便胡乱标记。

⑥创建组件

创建控制层组件

@Controller

public class UserController {

}

创建接口UserService

public interface UserService {

}

创建业务层组件UserServiceImpl

@Service

public class UserServiceImpl implements UserService {

}

创建接口UserDao

public interface UserDao {

}

创建持久层组件UserDaoImpl

@Repository

public class UserDaoImpl implements UserDao {

}

⑦扫描组件

情况一：最基本的扫描方式

<context:component-scan base-package=”com.atguigu”>

</context:component-scan>

情况二：指定要排除的组件

<context:component-scan base-package=”com.atguigu”>

<!-- context:exclude-filter标签：指定排除规则 -->

<!--

type：设置排除或包含的依据

type=”annotation”，根据注解排除，expression中设置要排除的注解的全类名

type=”assignable”，根据类型排除，expression中设置要排除的类型的全类名

-->

<context:exclude-filter type=”annotation” expression=”org.springframework.stereotype.Controller”/>

<!--<context:exclude-filter type=”assignable” expression=”com.atguigu.controller.UserController”/>-->

</context:component-scan>

情况三：仅扫描指定组件

<context:component-scan base-package=”com.atguigu” use-default-filters=”false”>

<!-- context:include-filter标签：指定在原有扫描规则的基础上追加的规则 -->

<!-- use-default-filters属性：取值false表示关闭默认扫描规则 -->

<!-- 此时必须设置use-default-filters=”false”，因为默认规则即扫描指定包下所有类 -->

<!--

type：设置排除或包含的依据

type=”annotation”，根据注解排除，expression中设置要排除的注解的全类名

type=”assignable”，根据类型排除，expression中设置要排除的类型的全类名

-->

<context:include-filter type=”annotation” expression=”org.springframework.stereotype.Controller”/>

<!--<context:include-filter type=”assignable” expression=”com.atguigu.controller.UserController”/>-->

</context:component-scan>

⑧测试

⑨组件所对应的bean的id

@Test

public void testAutowireByAnnotation(){ ApplicationContext ac = new

ClassPathXmlApplicationContext(“applicationContext.xml”); UserController userController = ac.getBean(UserController.class); System.out.println(userController);

UserService userService = ac.getBean(UserService.class); System.out.println(userService);

UserDao userDao = ac.getBean(UserDao.class); System.out.println(userDao);

}

在我们使用XML方式管理bean的时候，每个bean都有一个唯一标识，便于在其他地方引用。现在使用注解后，每个组件仍然应该有一个唯一标识。

默认情况

类名首字母小写就是bean的id。例如：UserController类对应的bean的id就是userController。自定义bean的id

可通过标识组件的注解的value属性设置自定义的bean的id

@Service(“userService”)// 默 认 为 userServiceImpl public class UserServiceImpl implements UserService {}

• • 1. 、实验二：基于注解的自动装配

①场景模拟

参考基于xml的自动装配

在UserController中声明UserService对象在UserServiceImpl中声明UserDao对象

②@Autowired注解

在成员变量上直接标记@Autowired注解即可完成自动装配，不需要提供setXxx()方法。以后我们在项 目中的正式用法就是这样。

@Controller

public class UserController {

@Autowired

private UserService userService;

public void saveUser(){ userService.saveUser();

}

}

public interface UserService { void saveUser();

}

@Service

public class UserServiceImpl implements UserService {

@Autowired

private UserDao userDao;

@Override

public void saveUser() { userDao.saveUser();

}

}

@Controller

public class UserController {

private UserService userService;

@Autowired

public void setUserService(UserService userService){ this.userService = userService;

}

public void saveUser(){

public interface UserDao { void saveUser();

}

@Repository

public class UserDaoImpl implements UserDao { @Override

public void saveUser() {

System.out.println(“保存成功”);

}

}

③@Autowired注解其他细节

@Autowired注解可以标记在构造器和set方法上

@Controller

public class UserController {

private UserService userService;

@Autowired

public UserController(UserService userService){ this.userService = userService;

}

public void saveUser(){ userService.saveUser();

}

}

④@Autowired工作流程

userService.saveUser();

}

}

首先根据所需要的组件类型到IOC容器中查找能够找到唯一的bean：直接执行装配

如果完全找不到匹配这个类型的bean：装配失败

和所需类型匹配的bean不止一个

没有@Qualifier注解：根据@Autowired标记位置成员变量的变量名作为bean的id进行 匹配

能够找到：执行装配找不到：装配失败

使用@Qualifier注解：根据@Qualifier注解中指定的名称作为bean的id进行匹配

能够找到：执行装配找不到：装配失败

@Controller

public class UserController {

@Autowired @Qualifier(“userServiceImpl”) private UserService userService;

public void saveUser(){ userService.saveUser();

}

}

public class CalculatorPureImpl implements Calculator {

@Override

public int add(int i, int j) {

int result = i + j; System.out.println(“方法内部 result = “ + result); return result;

}

3、AOP

@Autowired中有属性required，默认值为true，因此在自动装配无法找到相应的bean时，会装 配失败

可以将属性required的值设置为true，则表示能装就装，装不上就不装，此时自动装配的属性为默认值

但是实际开发时，基本上所有需要装配组件的地方都是必须装配的，用不上这个属性。

• 1. 、场景模拟
     1. 、声明接口

声明计算器接口Calculator，包含加减乘除的抽象方法

public interface Calculator {

int add(int i, int j);

int sub(int i, int j);

int mul(int i, int j);

int div(int i, int j);

}

• • 1. 、创建实现类

public class CalculatorLogImpl implements Calculator {

@Override

public int add(int i, int j) {

System.out.println(“[日志] add 方法开始了，参数是：” + i + “,” + j); int result = i + j;

@Override

public int sub(int i, int j) {

int result = i - j; System.out.println(“方法内部 result = “ + result);

return result;

}

@Override

public int mul(int i, int j) {

int result = i * j; System.out.println(“方法内部 result = “ + result);

return result;

}

@Override

public int div(int i, int j) {

int result = i / j;

System.out.println(“方法内部 result = “ + result);

return result;

}

}

、创建带日志功能的实现类

System.out.println(“方法内部 result = “ + result);

System.out.println(“[日志] add 方法结束了，结果是：” + result);

return result;

}

@Override

public int sub(int i, int j) {

System.out.println(“[日志] sub 方法开始了，参数是：” + i + “,” + j); int result = i - j;

System.out.println(“方法内部 result = “ + result);

System.out.println(“[日志] sub 方法结束了，结果是：” + result);

return result;

}

@Override

public int mul(int i, int j) {

System.out.println(“[日志] mul 方法开始了，参数是：” + i + “,” + j); int result = i * j;

System.out.println(“方法内部 result = “ + result);

System.out.println(“[日志] mul 方法结束了，结果是：” + result);

return result;

}

@Override

public int div(int i, int j) {

System.out.println(“[日志] div 方法开始了，参数是：” + i + “,” + j); int result = i / j;

System.out.println(“方法内部 result = “ + result);

System.out.println(“[日志] div 方法结束了，结果是：” + result);

return result;

}

}

、提出问题

①现有代码缺陷

针对带日志功能的实现类，我们发现有如下缺陷：

对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力附加功能分散在各个业务功能方法中，不利于统一维护

②解决思路

解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

③困难

解决问题的困难：要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方式没法解决。 所以需要引入新的技术。

• 1. 、代理模式
     1. 、概念

①介绍

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标 方法的时候，不再是直接对目标方法进行调用，而是通过代理类__间接__调用。让不属于目标方法核心逻辑 的代码从目标方法中剥离出来——__解耦__。调用目标方法时先调用代理对象的方法，减少对目标方法的调 用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

使用代理后：

②生活中的代理

广告商找大明星拍广告需要经过经纪人

合作伙伴找大老板谈合作要约见面时间需要经过秘书房产中介是买卖双方的代理

③相关术语

代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。目标：被代理“套用”了非核心逻辑代码的类、对象、方法。

• • 1. 、静态代理

创建静态代理类：

public class CalculatorStaticProxy implements Calculator {

// 将被代理的目标对象声明为成员变量

private Calculator target;

public CalculatorStaticProxy(Calculator target) { this.target = target;

}

@Override

public int add(int i, int j) {

// 附加功能由代理类中的代理方法来实现

System.out.println(“[日志] add 方法开始了，参数是：” + i + “,” + j);

// 通过目标对象来实现核心业务逻辑

int addResult = target.add(i, j);

System.out.println(“[日志] add 方法结束了，结果是：” + addResult);

静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来 说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代 码，日志功能还是分散的，没有统一管理。

return addResult;

}

}

提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理 类来实现。这就需要使用动态代理技术了。

• • 1. 、动态代理

生产代理对象的工厂类：

public class ProxyFactory {

private Object target;

public ProxyFactory(Object target) { this.target = target;

}

public Object getProxy(){

/**

• newProxyInstance()：创建一个代理实例
• 其中有三个参数：
• 1、classLoader：加载动态生成的代理类的类加载器
• 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
• 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接 口中的抽象方法

*/

ClassLoader classLoader = target.getClass().getClassLoader(); Class<?>[] interfaces = target.getClass().getInterfaces(); InvocationHandler invocationHandler = new InvocationHandler() {

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

/**

• • proxy：代理对象
  • method：代理对象需要实现的方法，即其中需要重写的方法
  • args：method所对应方法的参数
    1. 、测试

*/

Object result = null; try {

System.out.println(“[动态代理][日志] “+method.getName()+“，参

数：”+ Arrays.toString(args));

result = method.invoke(target, args);

System.out.println(“[动态代理][日志] “+method.getName()+“，结

果：”+ result);

} catch (Exception e) { e.printStackTrace();

System.out.println(“[动态代理][日志] “+method.getName()+“，异

常：”+e.getMessage());

} finally {

System.out.println(“[动态代理][日志] “+method.getName()+“，方法

执行完毕”);

}

return result;

}

};

return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);

}

}

@Test

public void testDynamicProxy(){

ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl()); Calculator proxy = (Calculator) factory.getProxy(); proxy.div(1,0);

//proxy.div(1,1);

}

• 1. 、AOP概念及相关术语
     1. 、概述

AOP（Aspect Oriented Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程的一种补充和完善，它以通过预编译方式和运行期动态代理方式实现在不修改源代码的情况 下给程序动态统一添加额外功能的一种技术。

• • 1. 、相关术语

①横切关注点

从每个方法中抽取出来的同一类非核心业务。在同一个项目中，我们可以使用多个横切关注点对相关方 法进行多个不同方面的增强。

这个概念不是语法层面天然存在的，而是根据附加功能的逻辑上的需要：有十个附加功能，就有十个横 切关注点。

②通知

每一个横切关注点上要做的事情都需要写一个方法来实现，这样的方法就叫通知方法。 前置通知：在被代理的目标方法__前__执行

返回通知：在被代理的目标方法__成功结束__后执行（__寿终正寝__）

异常通知：在被代理的目标方法__异常结束__后执行（__死于非命__） 后置通知：在被代理的目标方法__最终结束__后执行（__盖棺定论__）

环绕通知：使用try...catch...finally结构围绕__整个__被代理的目标方法，包括上面四种通知对应的所 有位置

③切面

封装通知方法的类。

④目标

被代理的目标对象。

⑤代理

向目标对象应用通知之后创建的代理对象。

⑥连接点

这也是一个纯逻辑概念，不是语法定义的。

把方法排成一排，每一个横切位置看成x轴方向，把方法从上到下执行的顺序看成y轴，x轴和y轴的交叉点就是连接点。

⑦切入点

定位连接点的方式。

每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物（从逻辑上来说）。 如果把连接点看作数据库中的记录，那么切入点就是查询记录的 SQL 语句。

Spring 的 AOP 技术可以通过切入点定位到特定的连接点。

切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

• • 1. 、作用

简化代码：把方法中固定位置的重复的代码__抽取__出来，让被抽取的方法更专注于自己的核心功能， 提高内聚性。

代码增强：把特定的功能封装到切面类中，看哪里有需要，就往上套，被__套用__了切面逻辑的方法就 被切面给增强了。

• 1. 、基于注解的AOP
     1. 、技术说明

动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因 为这个技术要求__代理对象和目标对象实现同样的接口__（兄弟两个拜把子模式）。

cglib：通过__继承被代理的目标类__（认干爹模式）实现代理，所以不需要目标类实现接口。

AspectJ：本质上是静态代理，__将代理逻辑“织入”被代理的目标类编译得到的字节码文件__，所以最 终效果是动态的。weaver就是织入器。Spring只是借用了AspectJ中的注解。

、准备工作

①添加依赖

在IOC所需依赖基础上再加入下面依赖即可：

<!-- spring-aspects会帮我们传递过来aspectjweaver -->

②准备被代理的目标资源

接口：

public interface Calculator {

int add(int i, int j);

int sub(int i, int j);

int mul(int i, int j);

int div(int i, int j);

}

实现类：

@Component

public class CalculatorPureImpl implements Calculator {

@Override

public int add(int i, int j) {

int result = i + j;

System.out.println(“方法内部 result = “ + result); return result;

}

@Override

public int sub(int i, int j) {

int result = i - j;

System.out.println(“方法内部 result = “ + result); return result;

}

@Override

public int mul(int i, int j) {

int result = i * j;

• • 1. 、创建切面类并配置

System.out.println(“方法内部 result = “ + result);

return result;

}

@Override

public int div(int i, int j) {

int result = i / j; System.out.println(“方法内部 result = “ + result); return result;

}

}

// @Aspect表示这个类是一个切面类@Aspect

// @Component注解保证这个切面类能够放入IOC容器@Component

public class LogAspect {

@Before(“execution(public int com.atguigu.aop.annotation.CalculatorImpl.* (..))“)

public void beforeMethod(JoinPoint joinPoint){

String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs());

System.out.println(“Logger-->前置通知，方法名：”+methodName+“，参

数：”+args);

}

@After(“execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))“) public void afterMethod(JoinPoint joinPoint){

String methodName = joinPoint.getSignature().getName(); System.out.println(“Logger-->后置通知，方法名：”+methodName);

}

@AfterReturning(value = “execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))“, returning = “result”)

public void afterReturningMethod(JoinPoint joinPoint, Object result){

String methodName = joinPoint.getSignature().getName();

System.out.println(“Logger-->返回通知，方法名：”+methodName+“，结 果：”+result);

}

@AfterThrowing(value = “execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))“, throwing = “ex”)

public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){ String methodName = joinPoint.getSignature().getName();

System.out.println(“Logger-->异常通知，方法名：”+methodName+“，异常：”+ex);

}

@Around(“execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))“) public Object aroundMethod(ProceedingJoinPoint joinPoint){

在Spring的配置文件中配置：

String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); Object result = null;

try {

System.out.println(“环绕通知-->目标对象方法执行之前”);

//目标对象（连接点）方法的执行result = joinPoint.proceed();

System.out.println(“环绕通知-->目标对象方法返回值之后”);

} catch (Throwable throwable) { throwable.printStackTrace(); System.out.println(“环绕通知-->目标对象方法出现异常时”);

} finally {

System.out.println(“环绕通知-->目标对象方法执行完毕”);

}

return result;

}

}

<!--

基于注解的AOP的实现：

1、将目标对象和切面交给IOC容器管理（注解+扫描）

2、开启AspectJ的自动代理，为目标对象自动生成代理

3、将切面类通过注解@Aspect标识

-->

<context:component-scan base-package=”com.atguigu.aop.annotation”>

</context:component-scan>

<aop:aspectj-autoproxy />

• • 1. 、各种通知

前置通知：使用@Before注解标识，在被代理的目标方法__前__执行

返回通知：使用@AfterReturning注解标识，在被代理的目标方法__成功结束__后执行（__寿终正寝__） 异常通知：使用@AfterThrowing注解标识，在被代理的目标方法__异常结束__后执行（__死于非命__） 后置通知：使用@After注解标识，在被代理的目标方法__最终结束__后执行（__盖棺定论__）

环绕通知：使用@Around注解标识，使用try...catch...finally结构围绕__整个__被代理的目标方法，包 括上面四种通知对应的所有位置

各种通知的执行顺序：

Spring版本5.3.x以前： 前置通知

目标操作

后置通知

返回通知或异常通知

Spring版本5.3.x以后：

前置通知目标操作

返回通知或异常通知后置通知

• • 1. 、切入点表达式语法

①作用

②语法细节

用*号代替“权限修饰符”和“返回值”部分表示“权限修饰符”和“返回值”不限

在包名的部分，一个“*”号只能代表包的层次结构中的一层，表示这一层是任意的。例如：*.Hello匹配com.Hello，不匹配com.atguigu.Hello

在包名的部分，使用“*..”表示包名任意、包的层次深度任意

在类名的部分，类名部分整体用*号代替，表示类名任意在类名的部分，可以使用*号代替类名的一部分

例如：*Service匹配所有名称以Service结尾的类或接口在方法名部分，可以使用*号表示方法名任意

在方法名部分，可以使用*号代替方法名的一部分

例如：*Operation匹配所有方法名以Operation结尾的方法在方法参数列表部分，使用(..)表示参数列表任意

在方法参数列表部分，使用(int,..)表示参数列表以一个int类型的参数开头在方法参数列表部分，基本数据类型和对应的包装类型是不一样的

切入点表达式中使用 int 和实际方法中 Integer 是不匹配的

在方法返回值部分，如果想要明确指定一个返回值类型，那么必须同时写明权限修饰符

例如：execution(public int *..*Service.*(.., int)) 正确例如：execution(* int *..*Service.*(.., int)) 错误

• • 1. 、重用切入点表达式

①声明

@Pointcut(“execution(* com.atguigu.aop.annotation.*.*(..))“) public void pointCut(){}

②在同一个切面中使用

@Before(“pointCut()“)

public void beforeMethod(JoinPoint joinPoint){

String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs());

System.out.println(“Logger-->前置通知，方法名：”+methodName+“，参数：”+args);

}

③在不同切面中使用

@Before(“com.atguigu.aop.CommonPointCut.pointCut()“) public void beforeMethod(JoinPoint joinPoint){

String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs());

System.out.println(“Logger-->前置通知，方法名：”+methodName+“，参数：”+args);

}

• • 1. 、获取通知的相关信息

①获取连接点信息

获取连接点信息可以在通知方法的参数位置设置JoinPoint类型的形参

@Before(“execution(public int com.atguigu.aop.annotation.CalculatorImpl.*(..))“) public void beforeMethod(JoinPoint joinPoint){

//获取连接点的签名信息

String methodName = joinPoint.getSignature().getName();

//获取目标方法到的实参信息

String args = Arrays.toString(joinPoint.getArgs()); System.out.println(“Logger-->前置通知，方法名：”+methodName+“，参数：”+args);

}

②获取目标方法的返回值

@AfterReturning中的属性returning，用来将通知方法的某个形参，接收目标方法的返回值

@AfterReturning(value = “execution(* com.atguigu.aop.annotation.CalculatorImpl.* (..))“, returning = “result”)

public void afterReturningMethod(JoinPoint joinPoint, Object result){ String methodName = joinPoint.getSignature().getName();

System.out.println(“Logger-->返回通知，方法名：”+methodName+“，结果：”+result);

}

③获取目标方法的异常

@AfterThrowing中的属性throwing，用来将通知方法的某个形参，接收目标方法的异常

• • 1. 、环绕通知

@AfterThrowing(value = “execution(* com.atguigu.aop.annotation.CalculatorImpl.* (..))“, throwing = “ex”)

public void afterThrowingMethod(JoinPoint joinPoint, Throwable ex){ String methodName = joinPoint.getSignature().getName();

System.out.println(“Logger-->异常通知，方法名：”+methodName+“，异常：”+ex);

}

@Around(“execution(* com.atguigu.aop.annotation.CalculatorImpl.*(..))“) public Object aroundMethod(ProceedingJoinPoint joinPoint){

String methodName = joinPoint.getSignature().getName(); String args = Arrays.toString(joinPoint.getArgs()); Object result = null;

try {

System.out.println(“环绕通知-->目标对象方法执行之前”);

//目标方法的执行，目标方法的返回值一定要返回给外界调用者result = joinPoint.proceed();

System.out.println(“环绕通知-->目标对象方法返回值之后”);

} catch (Throwable throwable) { throwable.printStackTrace();

System.out.println(“环绕通知-->目标对象方法出现异常时”);

} finally {

System.out.println(“环绕通知-->目标对象方法执行完毕”);

}

return result;

}

• • 1. 、切面的优先级

相同目标方法上同时存在多个切面时，切面的优先级控制切面的__内外嵌套__顺序。 优先级高的切面：外面

优先级低的切面：里面

使用@Order注解可以控制切面的优先级：

@Order(较小的数)：优先级高

@Order(较大的数)：优先级低

• 1. 、基于XML的AOP（了解）

-
-
1. 、准备工作

参考基于注解的AOP环境

• • 1. 、实现

<context:component-scan base-package=”com.atguigu.aop.xml”></context:component- scan>

aop:config

<!--配置切面类-->

<aop:aspect ref=”loggerAspect”>

<aop:pointcut id=”pointCut” expression=”execution(* com.atguigu.aop.xml.CalculatorImpl.*(..))“/>

<aop:before method=”beforeMethod” pointcut-ref=”pointCut”>

<aop:after method=”afterMethod” pointcut-ref=”pointCut”>

<aop:after-returning method=”afterReturningMethod” returning=”result” pointcut-ref=”pointCut”></aop:after-returning>

<aop:after-throwing method=”afterThrowingMethod” throwing=”ex” pointcut- ref=”pointCut”></aop:after-throwing>

<aop:around method=”aroundMethod” pointcut-ref=”pointCut”>

<aop:aspect ref=”validateAspect” order=”1”>

<aop:before method=”validateBeforeMethod” pointcut-ref=”pointCut”>

4、声明式事务

• 1. 、JdbcTemplate
     1. 、简介

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作

• • 1. 、准备工作

①加入依赖

②创建jdbc.properties

jdbc.user=root jdbc.password=atguigu

jdbc.url=jdbc:mysql://localhost:3306/ssm jdbc.driver=com.mysql.cj.jdbc.Driver

③配置Spring的配置文件

<!-- 导入外部属性文件 -->

<context:property-placeholder location=”classpath:jdbc.properties” />

<!-- 配置数据源 -->

<!-- 配置 JdbcTemplate -->

• • 1. 、测试

①在测试类装配 JdbcTemplate

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(“classpath:spring-jdbc.xml”) public class JDBCTemplateTest {

@Autowired

private JdbcTemplate jdbcTemplate;

}

②测试增删改功能

@Test

//测试增删改功能

public void testUpdate(){

String sql = “insert into t_emp values(null,?,?,?)“; int result = jdbcTemplate.update(sql, “张三”, 23, “男”); System.out.println(result);

}

③查询一条数据为实体类对象

④查询多条数据为一个list集合

@Test

//查询一条数据为一个实体类对象 public void testSelectEmpById(){

String sql = “select * from t_emp where id = ?”;

Emp emp = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<> (Emp.class), 1);

System.out.println(emp);

}

@Test

//查询多条数据为一个list集合public void testSelectList(){

String sql = “select * from t_emp”;

List list = jdbcTemplate.query(sql, new BeanPropertyRowMapper<> (Emp.class));

list.forEach(emp -> System.out.println(emp));

}

⑤查询单行单列的值

@Test

//查询单行单列的值

public void selectCount(){

String sql = “select count(id) from t_emp”;

Integer count = jdbcTemplate.queryForObject(sql, Integer.class); System.out.println(count);

}

• 1. 、声明式事务概念
     1. 、编程式事务

事务功能的相关操作全部通过自己编写代码来实现：

Connection conn = ...;

try {

// 开启事务：关闭事务的自动提交

conn.setAutoCommit(false);

// 核心操作

// 提交事务

conn.commit();

}catch(Exception e){

// 回滚事务

conn.rollBack();

}finally{

编程式的实现方式存在缺陷：

// 释放数据库连接

conn.close();

}

细节没有被屏蔽：具体操作过程中，所有细节都需要程序员自己来完成，比较繁琐。

代码复用性不高：如果没有有效抽取出来，每次实现功能都需要自己编写代码，代码就没有得到复 用。

• • 1. 、声明式事务

既然事务控制的代码有规律可循，代码的结构基本是确定的，所以框架就可以将固定模式的代码抽取出 来，进行相关的封装。

封装起来后，我们只需要在配置文件中进行简单的配置即可完成操作。好处1：提高开发效率

好处2：消除了冗余的代码

好处3：框架会综合考虑相关领域中在实际开发环境下有可能遇到的各种问题，进行了健壮性、性 能等各个方面的优化

所以，我们可以总结下面两个概念：

__编程式__：__自己写代码__实现功能

__声明式__：通过__配置__让__框架__实现功能

、基于注解的声明式事务

、准备工作

①加入依赖

jdbc.user=root jdbc.password=atguigu

jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC jdbc.driver=com.mysql.cj.jdbc.Driver

③配置Spring的配置文件

<!--扫描组件-->

<context:component-scan base-package=”com.atguigu.spring.tx.annotation”>

</context:component-scan>

<!-- 导入外部属性文件 -->

<context:property-placeholder location=”classpath:jdbc.properties” />

<!-- 配置数据源 -->

<!-- 配置 JdbcTemplate -->

④创建表

CREATE TABLE `t_book` (

`book_id` int(11) NOT NULL AUTO_INCREMENT COMMENT ‘主键’,

`book_name` varchar(20) DEFAULT NULL COMMENT ‘图书名称’,

`price` int(11) DEFAULT NULL COMMENT ‘价格’,

`stock` int(10) unsigned DEFAULT NULL COMMENT ‘库存（无符号）’, PRIMARY KEY (`book_id`)

) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

insert into `t_book`(`book_id`,`book_name`,`price`,`stock`) values (1,’斗破苍穹’,80,100),(2,’斗罗大陆’,50,100);

CREATE TABLE `t_user` (

`user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT ‘主键’,

`username` varchar(20) DEFAULT NULL COMMENT ‘用户名’,

`balance` int(10) unsigned DEFAULT NULL COMMENT ‘余额（无符号）’, PRIMARY KEY (`user_id`)

) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

insert into `t_user`(`user_id`,`username`,`balance`) values (1,’admin’,50);

⑤创建组件

创建BookController：

@Controller

public class BookController {

@Autowired

private BookService bookService;

public void buyBook(Integer bookId, Integer userId){ bookService.buyBook(bookId, userId);

}

}

创建接口BookService：

public interface BookService {

void buyBook(Integer bookId, Integer userId);

}

创建实现类BookServiceImpl：

@Service

public class BookServiceImpl implements BookService {

@Autowired

private BookDao bookDao;

@Override

public void buyBook(Integer bookId, Integer userId) {

//查询图书的价格

Integer price = bookDao.getPriceByBookId(bookId);

//更新图书的库存bookDao.updateStock(bookId);

//更新用户的余额bookDao.updateBalance(userId, price);

}

创建接口BookDao：

}

public interface BookDao {

Integer getPriceByBookId(Integer bookId);

void updateStock(Integer bookId);

void updateBalance(Integer userId, Integer price);

}

创建实现类BookDaoImpl：

@Repository

public class BookDaoImpl implements BookDao {

@Autowired

private JdbcTemplate jdbcTemplate;

@Override

public Integer getPriceByBookId(Integer bookId) {

String sql = “select price from t_book where book_id = ?”; return jdbcTemplate.queryForObject(sql, Integer.class, bookId);

}

@Override

public void updateStock(Integer bookId) {

String sql = “update t_book set stock = stock - 1 where book_id = ?”; jdbcTemplate.update(sql, bookId);

}

@Override

public void updateBalance(Integer userId, Integer price) {

String sql = “update t_user set balance = balance - ? where user_id =

?”;

jdbcTemplate.update(sql, price, userId);

}

}

• • 1. 、测试无事务情况

①创建测试类

②模拟场景

@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(“classpath:tx-annotation.xml”) public class TxByAnnotationTest {

@Autowired

private BookController bookController;

@Test

public void testBuyBook(){ bookController.buyBook(1, 1);

}

}

用户购买图书，先查询图书的价格，再更新图书的库存和用户的余额假设用户id为1的用户，购买id为1的图书

用户余额为50，而图书价格为80

购买图书之后，用户的余额为-30，数据库中余额字段设置了无符号，因此无法将-30插入到余额字段此时执行sql语句会抛出SQLException

③观察结果

因为没有添加事务，图书的库存更新了，但是用户的余额没有更新

显然这样的结果是错误的，购买图书是一个完整的功能，更新库存和更新余额要么都成功要么都失败

• • 1. 、加入事务

①添加事务配置

在Spring的配置文件中添加配置：

<!--

开启事务的注解驱动

通过注解@Transactional所标识的方法或标识的类中所有的方法，都会被事务管理器管理事务

-->

<!-- transaction-manager属性的默认值是transactionManager，如果事务管理器bean的id正好就是这个默认值，则可以省略这个属性 -->

<tx:annotation-driven transaction-manager=”transactionManager” />

注意：导入的名称空间需要 __tx 结尾__的那个。

②添加事务注解

因为service层表示业务逻辑层，一个方法表示一个完成的功能，因此处理事务一般在service层处理 在BookServiceImpl的buybook()添加注解@Transactional

③观察结果

由于使用了Spring的声明式事务，更新库存和更新余额都没有执行

• • 1. 、@Transactional注解标识的位置

@Transactional标识在方法上，咋只会影响该方法

@Transactional标识的类上，咋会影响类中所有的方法

• • 1. 、事务属性：只读

①介绍

对一个查询操作来说，如果我们把它设置成只读，就能够明确告诉数据库，这个操作不涉及写操作。这 样数据库就能够针对查询操作来进行优化。

②使用方式

@Transactional(readOnly = true)

public void buyBook(Integer bookId, Integer userId) {

//查询图书的价格

Integer price = bookDao.getPriceByBookId(bookId);

//更新图书的库存bookDao.updateStock(bookId);

//更新用户的余额bookDao.updateBalance(userId, price);

//System.out.println(1/0);

}

③注意

对增删改操作设置只读会抛出下面异常：

Caused by: java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed

• • 1. 、事务属性：超时

①介绍

事务在执行过程中，有可能因为遇到某些问题，导致程序卡住，从而长时间占用数据库资源。而长时间 占用资源，大概率是因为程序运行出现了问题（可能是Java程序或MySQL数据库或网络连接等等）。

此时这个很可能出问题的程序应该被回滚，撤销它已做的操作，事务结束，把资源让出来，让其他正常 程序可以执行。

概括来说就是一句话：超时回滚，释放资源。

②使用方式

@Transactional(timeout = 3)

public void buyBook(Integer bookId, Integer userId) { try {

TimeUnit.SECONDS.sleep(5);

} catch (InterruptedException e) { e.printStackTrace();

}

//查询图书的价格

Integer price = bookDao.getPriceByBookId(bookId);

//更新图书的库存bookDao.updateStock(bookId);

//更新用户的余额bookDao.updateBalance(userId, price);

//System.out.println(1/0);

}

③观察结果

执行过程中抛出异常：

org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Fri Jun 04 16:25:39 CST 2022

、事务属性：回滚策略

①介绍

声明式事务默认只针对运行时异常回滚，编译时异常不回滚。可以通过@Transactional中相关属性设置回滚策略

rollbackFor属性：需要设置一个Class类型的对象

rollbackForClassName属性：需要设置一个字符串类型的全类名

noRollbackFor属性：需要设置一个Class类型的对象rollbackFor属性：需要设置一个字符串类型的全类名

②使用方式

@Transactional(noRollbackFor = ArithmeticException.class)

//@Transactional(noRollbackForClassName = “java.lang.ArithmeticException”) public void buyBook(Integer bookId, Integer userId) {

//查询图书的价格

Integer price = bookDao.getPriceByBookId(bookId);

//更新图书的库存bookDao.updateStock(bookId);

//更新用户的余额bookDao.updateBalance(userId, price); System.out.println(1/0);

}

③观察结果

虽然购买图书功能中出现了数学运算异常（ArithmeticException），但是我们设置的回滚策略是，当 出现ArithmeticException不发生回滚，因此购买图书的操作正常执行

• • 1. 、事务属性：事务隔离级别

①介绍

数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。一个事 务与其他事务隔离的程度称为隔离级别。SQL标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发性越弱。

隔离级别一共有四种：

读未提交：READ UNCOMMITTED

允许Transaction01读取Transaction02未提交的修改。读已提交：READ COMMITTED、

要求Transaction01只能读取Transaction02已提交的修改。

可重复读：REPEATABLE READ

确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其它事务对这个字段进行更新。

串行化：SERIALIZABLE

确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其它事务对这个表进行添加、更新、删除操作。可以避免任何并发问题，但性能十分低下。

各个隔离级别解决并发问题的能力见下表：

隔离级别

脏读

不可重复读

幻读

READ UNCOMMITTED

有

有

有

READ COMMITTED

无

有

有

REPEATABLE READ

无

无

有

SERIALIZABLE

无

无

无

各种数据库产品对事务隔离级别的支持程度：

隔离级别

Oracle

MySQL

READ UNCOMMITTED

×

√

READ COMMITTED

√(默认)

√

REPEATABLE READ

×

√(默认)

SERIALIZABLE

√

√

②使用方式

@Transactional(isolation = Isolation.DEFAULT)//使用数据库默认的隔离级别@Transactional(isolation = Isolation.READ_UNCOMMITTED)//读未提交@Transactional(isolation = Isolation.READ_COMMITTED)//读已提交@Transactional(isolation = Isolation.REPEATABLE_READ)//可重复读@Transactional(isolation = Isolation.SERIALIZABLE)//串行化

• • 1. 、事务属性：事务传播行为

①介绍

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中 运行，也可能开启一个新事务，并在自己的事务中运行。

②测试

创建接口CheckoutService：

public interface CheckoutService {

void checkout(Integer[] bookIds, Integer userId);

}

创建实现类CheckoutServiceImpl：

@Service

public class CheckoutServiceImpl implements CheckoutService {

@Autowired

private BookService bookService;

@Override @Transactional

//一次购买多本图书

public void checkout(Integer[] bookIds, Integer userId) { for (Integer bookId : bookIds) {

bookService.buyBook(bookId, userId);

}

}

}

在BookController中添加方法：

@Autowired

private CheckoutService checkoutService;

public void checkout(Integer[] bookIds, Integer userId){ checkoutService.checkout(bookIds, userId);

}

在数据库中将用户的余额修改为100元

③观察结果

可以通过@Transactional中的propagation属性设置事务传播行为

修改BookServiceImpl中buyBook()上，注解@Transactional的propagation属性

@Transactional(propagation = Propagation.REQUIRED)，默认情况，表示如果当前线程上有已经开启的事务可用，那么就在这个事务中运行。经过观察，购买图书的方法buyBook()在checkout()中被调 用，checkout()上有事务注解，因此在此事务中执行。所购买的两本图书的价格为80和50，而用户的余 额为100，因此在购买第二本图书时余额不足失败，导致整个checkout()回滚，即只要有一本书买不

了，就都买不了

@Transactional(propagation = Propagation.REQUIRES_NEW)，表示不管当前线程上是否有已经开启的事务，都要开启新事务。同样的场景，每次购买图书都是在buyBook()的事务中执行，因此第一本图书购买成功，事务结束，第二本图书购买失败，只在第二次的buyBook()中回滚，购买第一本图书不受影响，即能买几本就买几本

4.4、基于XML的声明式事务

• • 1. 、场景模拟

参考基于注解的声明式事务

• • 1. 、修改Spring配置文件

将Spring配置文件中去掉tx:annotation-driven 标签，并添加配置：

aop:config

<!-- 配置事务通知和切入点表达式 -->

<aop:advisor advice-ref=”txAdvice” pointcut=”execution(* com.atguigu.spring.tx.xml.service.impl.*.*(..))“>

<!-- tx:advice标签：配置事务通知 -->

<!-- id属性：给事务通知标签设置唯一标识，便于引用 -->

<!-- transaction-manager属性：关联事务管理器 -->

<tx:advice id=”txAdvice” transaction-manager=”transactionManager”>

tx:attributes

<!-- tx:method标签：配置具体的事务方法 -->

<!-- name属性：指定方法名，可以使用星号代表多个字符 -->

<tx:method name=”get*“ read-only=”true”/>

<tx:method name=”query*“ read-only=”true”/>

<tx:method name=”find*“ read-only=”true”/>

<!-- read-only属性：设置只读属性 -->

<!-- rollback-for属性：设置回滚的异常 -->

<!-- no-rollback-for属性：设置不回滚的异常 -->

<!-- isolation属性：设置事务的隔离级别 -->

<!-- timeout属性：设置事务的超时属性 -->

<!-- propagation属性：设置事务的传播行为 -->

<tx:method name=”save*“ read-only=”false” rollback- for=”java.lang.Exception” propagation=”REQUIRES_NEW”/>

<tx:method name=”update*“ read-only=”false” rollback- for=”java.lang.Exception” propagation=”REQUIRES_NEW”/>

<tx:method name=”delete*“ read-only=”false” rollback- for=”java.lang.Exception” propagation=”REQUIRES_NEW”/>

注意：基于xml实现的声明式事务，必须引入aspectJ的依赖

三、SpringMVC

1、SpringMVC简介

• 1. 、什么是MVC

MVC是一种软件架构的思想，将软件按照模型、视图、控制器来划分M：Model，模型层，指工程中的JavaBean，作用是处理数据

JavaBean分为两类：

一类称为实体类Bean：专门存储业务数据的，如 Student、User 等

一类称为业务处理 Bean：指 Service 或 Dao 对象，专门用于处理业务逻辑和数据访问。

V：View，视图层，指工程中的html或jsp等页面，作用是与用户进行交互，展示数据C：Controller，控制层，指工程中的servlet，作用是接收请求和响应浏览器

MVC的工作流程： 用户通过视图层发送请求到服务器，在服务器中请求被Controller接收，Controller 调用相应的Model层处理请求，处理完毕将结果返回到Controller，Controller再根据请求处理的结果 找到相应的View视图，渲染数据后最终响应给浏览器

• 1. 、什么是SpringMVC

SpringMVC是Spring的一个后续产品，是Spring的一个子项目

SpringMVC 是 Spring 为表述层开发提供的一整套完备的解决方案。在表述层框架历经 Strust、WebWork、Strust2 等诸多产品的历代更迭之后，目前业界普遍选择了 SpringMVC 作为 Java EE 项目表述层开发的__首选方案__。

注：三层架构分为表述层（或表示层）、业务逻辑层、数据访问层，表述层表示前台页面和后台

servlet

• 1. 、SpringMVC的特点

__Spring 家族原生产品__，与 IOC 容器等基础设施无缝对接

__基于原生的Servlet__，通过了功能强大的__前端控制器DispatcherServlet__，对请求和响应进行统一 处理

表述层各细分领域需要解决的问题__全方位覆盖__，提供__全面解决方案代码清新简洁__，大幅度提升开发效率

内部组件化程度高，可插拔式组件__即插即用__，想要什么功能配置相应组件即可

__性能卓著__，尤其适合现代大型、超大型互联网项目要求

2、入门案例

• 1. 、开发环境

IDE：idea 2019.2

构建工具：maven3.5.4 服务器：tomcat8.5

Spring版本：5.3.1

• 1. 、创建maven工程

①添加web模块

②打包方式：war

③引入依赖

注：由于 Maven 的传递性，我们不必将所有需要的包全部配置依赖，而是配置最顶端的依赖，其他靠传递性导入。

• 1. 、配置web.xml

注册SpringMVC的前端控制器DispatcherServlet

①默认配置方式

此配置作用下，SpringMVC的配置文件默认位于WEB-INF下，默认名称为<servlet-name>- servlet.xml，例如，以下配置所对应SpringMVC的配置文件位于WEB-INF下，文件名为springMVC- servlet.xml

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->

<servlet-mapping>

<servlet-name>springMVC</servlet-name>

<!--

设置springMVC的核心控制器所能处理的请求的请求路径

/所匹配的请求可以是/login或.html或.js或.css方式的请求路径 但是/不能匹配.jsp请求路径的请求

-->

<url-pattern>/</url-pattern>

</servlet-mapping>

②扩展配置方式

可通过init-param标签设置SpringMVC配置文件的位置和名称，通过load-on-startup标签设置

SpringMVC前端控制器DispatcherServlet的初始化时间

<!-- 配置SpringMVC的前端控制器，对浏览器发送的请求统一进行处理 -->

<servlet-mapping>

<servlet-name>springMVC</servlet-name>

<!--

设置springMVC的核心控制器所能处理的请求的请求路径

/所匹配的请求可以是/login或.html或.js或.css方式的请求路径 但是/不能匹配.jsp请求路径的请求

-->

<url-pattern>/</url-pattern>

</servlet-mapping>

注：

• 1. 、创建请求控制器

<url-pattern>标签中使用/和/*的区别：

/所匹配的请求可以是/login或.html或.js或.css方式的请求路径，但是/不能匹配.jsp请求路径的请 求

因此就可以避免在访问jsp页面时，该请求被DispatcherServlet处理，从而找不到相应的页面

/*则能够匹配所有请求，例如在使用过滤器时，若需要对所有请求进行过滤，就需要使用/*的写 法

由于前端控制器对浏览器发送的请求进行了统一的处理，但是具体的请求有不同的处理过程，因此需要 创建处理具体请求的类，即请求控制器

请求控制器中每一个处理请求的方法成为控制器方法

因为SpringMVC的控制器由一个POJO（普通的Java类）担任，因此需要通过@Controller注解将其标识为一个控制层组件，交给Spring的IoC容器管理，此时SpringMVC才能够识别控制器的存在

@Controller

public class HelloController {

}

• 1. 、创建SpringMVC的配置文件

<!-- 自动扫描包 -->

<context:component-scan base-package=”com.atguigu.mvc.controller”/>

<!-- 配置Thymeleaf视图解析器 -->

<!--

处理静态资源，例如html、js、css、jpg

若只设置该标签，则只能访问静态资源，其他请求则无法访问

• 1. 、测试HelloWorld

此时必须设置mvc:annotation\-driven/解决问题

-->

mvc:default\-servlet\-handler/

<!-- 开启mvc注解驱动 -->

mvc:annotation\-driven

mvc:message\-converters

<!-- 处理响应中文内容乱码 -->

</mvc:message-converters>

</mvc:annotation-driven>

①实现对首页的访问

在请求控制器中创建处理请求的方法

// @RequestMapping注解：处理请求和控制器方法之间的映射关系

// @RequestMapping注解的value属性可以通过请求地址匹配请求，/表示的当前工程的上下文路径

// localhost:8080/springMVC/ @RequestMapping(“/“)

public String index() {

//设置视图名称return “index”;

}

②通过超链接跳转到指定页面

在主页index.html中设置超链接

<!DOCTYPE html>

首页

HelloWorld

在请求控制器中创建处理请求的方法

• 1. 、总结

@RequestMapping(“/hello”) public String HelloWorld() {

return “target”;

}

浏览器发送请求，若请求地址符合前端控制器的url-pattern，该请求就会被前端控制器

DispatcherServlet处理。前端控制器会读取SpringMVC的核心配置文件，通过扫描组件找到控制器， 将请求地址和控制器中@RequestMapping注解的value属性值进行匹配，若匹配成功，该注解所标识的 控制器方法就是处理请求的方法。处理请求的方法需要返回一个字符串类型的视图名称，该视图名称会 被视图解析器解析，加上前缀和后缀组成视图的路径，通过Thymeleaf对视图进行渲染，最终转发到视图所对应页面

3、@RequestMapping注解

• 1. 、@RequestMapping注解的功能

从注解名称上我们可以看到，@RequestMapping注解的作用就是将请求和处理请求的控制器方法关联起来，建立映射关系。

SpringMVC 接收到指定的请求，就会来找到在映射关系中对应的控制器方法来处理这个请求。

• 1. 、@RequestMapping注解的位置

@RequestMapping标识一个类：设置映射请求的请求路径的初始信息

@RequestMapping标识一个方法：设置映射请求请求路径的具体信息

@Controller @RequestMapping(“/test”)

public class RequestMappingController {

//此时请求映射所映射的请求的请求路径为：/test/testRequestMapping @RequestMapping(“/testRequestMapping”)

public String testRequestMapping(){ return “success”;

}

}

• 1. 、@RequestMapping注解的value属性

@RequestMapping注解的value属性通过请求的请求地址匹配请求映射

@RequestMapping注解的value属性是一个字符串类型的数组，表示该请求映射能够匹配多个请求地址 所对应的请求

@RequestMapping注解的value属性必须设置，至少通过请求地址匹配请求映射

测试@RequestMapping的value属性--

/testRequestMapping

测试@RequestMapping的value属性-->/test

• 1. 、@RequestMapping注解的method属性

@RequestMapping(

value = {“/testRequestMapping”, “/test”}

)

public String testRequestMapping(){ return “success”;

}

@RequestMapping注解的method属性通过请求的请求方式（get或post）匹配请求映射

@RequestMapping注解的method属性是一个RequestMethod类型的数组，表示该请求映射能够匹配 多种请求方式的请求

若当前请求的请求地址满足请求映射的value属性，但是请求方式不满足method属性，则浏览器报错

405：Request method ‘POST’ not supported

测试@RequestMapping的value属性-->/test

@RequestMapping(

value = {“/testRequestMapping”, “/test”}, method = {RequestMethod.GET, RequestMethod.POST}

)

public String testRequestMapping(){ return “success”;

}

注：

1、对于处理指定请求方式的控制器方法，SpringMVC中提供了@RequestMapping的派生注解 处理get请求的映射-->@GetMapping

处理post请求的映射-->@PostMapping

处理put请求的映射-->@PutMapping

处理delete请求的映射-->@DeleteMapping

2、常用的请求方式有get，post，put，delete

但是目前浏览器只支持get和post，若在form表单提交时，为method设置了其他请求方式的字符 串（put或delete），则按照默认的请求方式get处理

若要发送put和delete请求，则需要通过spring提供的过滤器HiddenHttpMethodFilter，在

RESTful部分会讲到

• 1. 、@RequestMapping注解的params属性（了解）

@RequestMapping注解的params属性通过请求的请求参数匹配请求映射

@RequestMapping注解的params属性是一个字符串类型的数组，可以通过四种表达式设置请求参数 和请求映射的匹配关系

“param”：要求请求映射所匹配的请求必须携带param请求参数

“!param”：要求请求映射所匹配的请求必须不能携带param请求参数

“param=value”：要求请求映射所匹配的请求必须携带param请求参数且param=value

“param!=value”：要求请求映射所匹配的请求必须携带param请求参数但是param!=value

测试@RequestMapping的

params属性-->/test

@RequestMapping(

value = {“/testRequestMapping”, “/test”}

,method = {RequestMethod.GET, RequestMethod.POST}

,params = {“username”,”password!=123456”}

)

public String testRequestMapping(){ return “success”;

}

注：

若当前请求满足@RequestMapping注解的value和method属性，但是不满足params属性，此时 页面回报错400：Parameter conditions “username, password!=123456” not met for actual request parameters: username={admin}, password={123456}

• 1. 、@RequestMapping注解的headers属性（了解）

@RequestMapping注解的headers属性通过请求的请求头信息匹配请求映射

@RequestMapping注解的headers属性是一个字符串类型的数组，可以通过四种表达式设置请求头信 息和请求映射的匹配关系

“header”：要求请求映射所匹配的请求必须携带header请求头信息 “!header”： 要 求 请 求 映 射 所 匹 配 的 请 求 必 须 不 能 携 带 header 请 求 头 信 息 “header=value”：要求请求映射所匹配的请求必须携带header请求头信息且header=value “header!=value”：要求请求映射所匹配的请求必须携带header请求头信息且header!=value

若当前请求满足@RequestMapping注解的value和method属性，但是不满足headers属性，此时页面 显示404错误，即资源未找到

• 1. 、SpringMVC支持ant风格的路径

？：表示任意的单个字符

*：表示任意的0个或多个字符

**：表示任意层数的任意目录

注意：在使用**时，只能使用/**/xxx的方式

• 1. 、SpringMVC支持路径中的占位符（重点）

原始方式：/deleteUser?id=1 rest方式：/user/delete/1

SpringMVC路径中的占位符常用于RESTful风格中，当请求路径中将某些数据通过路径的方式传输到服 务器中，就可以在相应的@RequestMapping注解的value属性中通过占位符{xxx}表示传输的数据，在 通过@PathVariable注解，将占位符所表示的数据赋值给控制器方法的形参

测试路径中的占位符-->/testRest

@RequestMapping(“/testRest/{id}/{username}“)

public String testRest(@PathVariable(“id”) String id, @PathVariable(“username”) String username){

System.out.println(“id:”+id+“,username:”+username); return “success”;

}

//最终输出的内容为-->id:1,username:admin

4、SpringMVC获取请求参数

• 1. 、通过ServletAPI获取

将HttpServletRequest作为控制器方法的形参，此时HttpServletRequest类型的参数表示封装了当前请求的请求报文的对象

@RequestMapping(“/testParam”)

public String testParam(HttpServletRequest request){ String username = request.getParameter(“username”); String password = request.getParameter(“password”);

System.out.println(“username:”+username+“,password:”+password); return “success”;

}

• 1. 、通过控制器方法的形参获取请求参数

在控制器方法的形参位置，设置和请求参数同名的形参，当浏览器发送请求，匹配到请求映射时，在

DispatcherServlet中就会将请求参数赋值给相应的形参

测试获取请求参数--

/testParam

@RequestMapping(“/testParam”)

public String testParam(String username, String password){ System.out.println(“username:”+username+“,password:”+password); return “success”;

}

注：

若请求所传输的请求参数中有多个同名的请求参数，此时可以在控制器方法的形参中设置字符串 数组或者字符串类型的形参接收此请求参数

若使用字符串数组类型的形参，此参数的数组中包含了每一个数据

若使用字符串类型的形参，此参数的值为每个数据中间使用逗号拼接的结果

• 1. 、@RequestParam

@RequestParam是将请求参数和控制器方法的形参创建映射关系@RequestParam 注 解 一 共 有 三 个 属 性 ： value：指定为形参赋值的请求参数的参数名

required：设置是否必须传输此请求参数，默认值为true

若设置为true时，则当前请求必须传输value所指定的请求参数，若没有传输该请求参数，且没有设置

defaultValue属性，则页面报错400：Required String parameter ‘xxx’ is not present；若设置为

false，则当前请求不是必须传输value所指定的请求参数，若没有传输，则注解所标识的形参的值为

null

defaultValue：不管required属性值为true或false，当value所指定的请求参数没有传输或传输的值为””时，则使用默认值为形参赋值

• 1. 、@RequestHeader

@RequestHeader是将请求头信息和控制器方法的形参创建映射关系

@RequestHeader注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

• 1. 、@CookieValue

@CookieValue是将cookie数据和控制器方法的形参创建映射关系

@CookieValue注解一共有三个属性：value、required、defaultValue，用法同@RequestParam

• 1. 、通过POJO获取请求参数

可以在控制器方法的形参位置设置一个实体类类型的形参，此时若浏览器传输的请求参数的参数名和实 体类中的属性名一致，那么请求参数就会为此属性赋值

用户名：

密码：

性别：男女

年龄：

邮箱：

@RequestMapping(“/testpojo”) public String testPOJO(User user){

System.out.println(user); return “success”;

}

//最终结果-->User{id=null, username=’张三’, password=’123’, age=23, sex=’男’, email=‘123@qq.com’}

• 1. 、解决获取请求参数的乱码问题

解决获取请求参数的乱码问题，可以使用SpringMVC提供的编码过滤器CharacterEncodingFilter，但是必须在web.xml中进行注册

<!--配置springMVC的编码过滤器-->

注：

<filter-name>CharacterEncodingFilter</filter-name>

<filter- class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>UTF-8</param-value>

</init-param>

<init-param>

<param-name>forceEncoding</param-name>

<param-value>true</param-value>

</init-param>

<filter-mapping>

<filter-name>CharacterEncodingFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

SpringMVC中处理编码的过滤器一定要配置到其他过滤器之前，否则无效

5、域对象共享数据

• 1. 、使用ServletAPI向request域对象共享数据

@RequestMapping(“/testServletAPI”)

public String testServletAPI(HttpServletRequest request){ request.setAttribute(“testScope”, “hello,servletAPI”); return “success”;

}

• 1. 、使用ModelAndView向request域对象共享数据

@RequestMapping(“/testModelAndView”) public ModelAndView testModelAndView(){

/**

• ModelAndView有Model和View的功能
• Model主要用于向请求域共享数据
• View主要用于设置视图，实现页面跳转

*/

ModelAndView mav = new ModelAndView();

//向请求域共享数据

mav.addObject(“testScope”, “hello,ModelAndView”);

//设置视图，实现页面跳转mav.setViewName(“success”); return mav;

}

• 1. 、使用Model向request域对象共享数据
  2. 、使用map向request域对象共享数据

@RequestMapping(“/testModel”)

public String testModel(Model model){ model.addAttribute(“testScope”, “hello,Model”); return “success”;

}

@RequestMapping(“/testMap”)

public String testMap(Map<String, Object> map){ map.put(“testScope”, “hello,Map”);

return “success”;

}

• 1. 、使用ModelMap向request域对象共享数据

@RequestMapping(“/testModelMap”)

public String testModelMap(ModelMap modelMap){ modelMap.addAttribute(“testScope”, “hello,ModelMap”); return “success”;

}

• 1. 、Model、ModelMap、Map的关系

Model、ModelMap、Map类型的参数其实本质上都是 BindingAwareModelMap 类型的

public interface Model{}

public class ModelMap extends LinkedHashMap<String, Object> {} public class ExtendedModelMap extends ModelMap implements Model {} public class BindingAwareModelMap extends ExtendedModelMap {}

• 1. 、向session域共享数据

@RequestMapping(“/testSession”)

public String testSession(HttpSession session){ session.setAttribute(“testSessionScope”, “hello,session”); return “success”;

}

• 1. 、向application域共享数据

@RequestMapping(“/testApplication”)

public String testApplication(HttpSession session){ ServletContext application = session.getServletContext();

application.setAttribute(“testApplicationScope”, “hello,application”); return “success”;

}

6、SpringMVC的视图

SpringMVC中的视图是View接口，视图的作用渲染数据，将模型Model中的数据展示给用户

SpringMVC视图的种类很多，默认有转发视图和重定向视图 当工程引入jstl的依赖，转发视图会自动转换为JstlView

若使用的视图技术为Thymeleaf，在SpringMVC的配置文件中配置了Thymeleaf的视图解析器，由此视 图解析器解析之后所得到的是ThymeleafView

• 1. 、ThymeleafView

当控制器方法中所设置的视图名称没有任何前缀时，此时的视图名称会被SpringMVC配置文件中所配置的视图解析器解析，视图名称拼接视图前缀和视图

后缀所得到的最终路径，会通过转发的方式实现跳转

@RequestMapping(“/testHello”) public String testHello(){

return “hello”;

}

• 1. 、转发视图

SpringMVC中默认的转发视图是InternalResourceView SpringMVC中创建转发视图的情况：

当控制器方法中所设置的视图名称以”forward:”为前缀时，创建InternalResourceView视图，此时的视图名称不会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”forward:”去掉，剩余部 分作为最终路径通过转发的方式实现跳转

例如”forward:/“，”forward:/employee”

@RequestMapping(“/testForward”) public String testForward(){

return “forward:/testHello”;

}

• 1. 、重定向视图

SpringMVC中默认的重定向视图是RedirectView

当控制器方法中所设置的视图名称以”redirect:”为前缀时，创建RedirectView视图，此时的视图名称不 会被SpringMVC配置文件中所配置的视图解析器解析，而是会将前缀”redirect:”去掉，剩余部分作为最 终路径通过重定向的方式实现跳转

例如”redirect:/“，”redirect:/employee”

@RequestMapping(“/testRedirect”) public String testRedirect(){

return “redirect:/testHello”;

}

注：

重定向视图在解析时，会先将redirect:前缀去掉，然后会判断剩余部分是否以/开头，若是则会自动拼接上下文路径

• 1. 、视图控制器view-controller

当控制器方法中，仅仅用来实现页面跳转，即只需要设置视图名称时，可以将处理器方法使用view- controller标签进行表示

<!--

path：设置处理的请求地址

view-name：设置请求地址所对应的视图名称

-->

<mvc:view-controller path=”/testView” view-name=”success”></mvc:view-controller>

注：

当SpringMVC中设置任何一个view-controller时，其他控制器中的请求映射将全部失效，此时需 要在SpringMVC的核心配置文件中设置开启mvc注解驱动的标签：

<mvc:annotation-driven />

7、RESTful

• 1. 、RESTful简介

REST：__Re__presentational __S__tate __T__ransfer，表现层资源状态转移。

①资源

资源是一种看待服务器的方式，即，将服务器看作是由很多离散的资源组成。每个资源是服务器上一个 可命名的抽象概念。因为资源是一个抽象的概念，所以它不仅仅能代表服务器文件系统中的一个文件、 数据库中的一张表等等具体的东西，可以将资源设计的要多抽象有多抽象，只要想象力允许而且客户端 应用开发者能够理解。与面向对象设计类似，资源是以名词为核心来组织的，首先关注的是名词。一个 资源可以由一个或多个URI来标识。URI既是资源的名称，也是资源在Web上的地址。对某个资源感兴趣的客户端应用，可以通过资源的URI与其进行交互。

②资源的表述

资源的表述是一段对于资源在某个特定时刻的状态的描述。可以在客户端-服务器端之间转移（交

换）。资源的表述可以有多种格式，例如HTML/XML/JSON/纯文本/图片/视频/音频等等。资源的表述格式可以通过协商机制来确定。请求-响应方向的表述通常使用不同的格式。

③状态转移

状态转移说的是：在客户端和服务器端之间转移（transfer）代表资源状态的表述。通过转移和操作资源的表述，来间接实现操作资源的目的。

• 1. 、RESTful的实现

具体说，就是 HTTP 协议里面，四个表示操作方式的动词：GET、POST、PUT、DELETE。

它们分别对应四种基本操作：GET 用来获取资源，POST 用来新建资源，PUT 用来更新资源，DELETE 用来删除资源。

REST 风格提倡 URL 地址使用统一的风格设计，从前到后各个单词使用斜杠分开，不使用问号键值对方式携带请求参数，而是将要发送给服务器的数据作为 URL 地址的一部分，以保证整体风格的一致性。

操作

传统方式

REST风格

查询操作

getUserById?id=1

user/1-->get请求方式

保存操作

saveUser

user-->post请求方式

删除操作

deleteUser?id=1

user/1-->delete请求方式

更新操作

updateUser

user-->put请求方式

• 1. 、HiddenHttpMethodFilter

由于浏览器只支持发送get和post方式的请求，那么该如何发送put和delete请求呢？

SpringMVC 提供了 __HiddenHttpMethodFilter __帮助我们__将 POST 请求转换为 DELETE 或 PUT 请求HiddenHttpMethodFilter __处 理 put 和 delete 请 求 的 条 件 ： a>当前请求的请求方式必须为post b>当前请求必须传输请求参数_method

满足以上条件，__HiddenHttpMethodFilter __过滤器就会将当前请求的请求方式转换为请求参数

_method的值，因此请求参数_method的值才是最终的请求方式

在web.xml中注册__HiddenHttpMethodFilter__

<filter-mapping>

<filter-name>HiddenHttpMethodFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

注：

String paramValue = request.getParameter(this.methodParam);

8、RESTful案例

目前为止，SpringMVC中提供了两个过滤器：CharacterEncodingFilter和

HiddenHttpMethodFilter

在web.xml中注册时，必须先注册CharacterEncodingFilter，再注册HiddenHttpMethodFilter 原因：

在 CharacterEncodingFilter 中通过 request.setCharacterEncoding(encoding) 方法设置字符集的

request.setCharacterEncoding(encoding) 方法要求前面不能有任何获取请求参数的操作而 HiddenHttpMethodFilter 恰恰有一个获取请求方式的操作：

• 1. 、准备工作

和传统 CRUD 一样，实现对员工信息的增删改查。搭建环境

准备实体类

更多Java –大数据 – 前端 – UI/UE - Android - 人工智能资料下载，可访问百度：尚硅谷官网(www.atguigu.com)

package com.atguigu.mvc.bean;

public class Employee {

private Integer id; private String lastName;

private String email;

//1 male, 0 female private Integer gender;

public Integer getId() { return id;

}

public void setId(Integer id) { this.id = id;

}

public String getLastName() { return lastName;

}

public void setLastName(String lastName) { this.lastName = lastName;

}

public String getEmail() { return email;

}

public void setEmail(String email) { this.email = email;

准备dao模拟数据

}

public Integer getGender() { return gender;

}

public void setGender(Integer gender) { this.gender = gender;

}

public Employee(Integer id, String lastName, String email, Integer gender) {

super(); this.id = id;

this.lastName = lastName; this.email = email; this.gender = gender;

}

public Employee() {

}

}

package com.atguigu.mvc.dao;

import java.util.Collection; import java.util.HashMap; import java.util.Map;

import com.atguigu.mvc.bean.Employee;

import org.springframework.stereotype.Repository;

@Repository

public class EmployeeDao {

private static Map<Integer, Employee> employees = null;

static{

employees = new HashMap<Integer, Employee>();

employees.put(1001, new Employee(1001, “E-AA”, “aa@163.com“, 1)); employees.put(1002, new Employee(1002, “E-BB”, “bb@163.com“, 1)); employees.put(1003, new Employee(1003, “E-CC”, “cc@163.com“, 0)); employees.put(1004, new Employee(1004, “E-DD”, “dd@163.com“, 0)); employees.put(1005, new Employee(1005, “E-EE”, “ee@163.com“, 1));

}

private static Integer initId = 1006;

public void save(Employee employee){ if(employee.getId() == null){

employee.setId(initId++);

}

employees.put(employee.getId(), employee);

• 1. 、功能清单

}

public Collection getAll(){ return employees.values();

}

public Employee get(Integer id){ return employees.get(id);

}

public void delete(Integer id){ employees.remove(id);

}

}

功能

URL 地址

请求方式

访问首页√

/

GET

查询全部数据√

/employee

GET

删除√

/employee/2

DELETE

跳转到添加数据页面√

/toAdd

GET

执行保存√

/employee

POST

跳转到更新数据页面√

/employee/2

GET

执行更新√

/employee

PUT

• 1. 、具体功能：访问首页

①配置view-controller

<mvc:view-controller path=”/“ view-name=”index”/>

②创建页面

<!DOCTYPE html>

首页

访问员工信息

• 1. 、具体功能：查询所有员工数据

①控制器方法

②创建employee_list.html

@RequestMapping(value = “/employee”, method = RequestMethod.GET) public String getEmployeeList(Model model){

Collection employeeList = employeeDao.getAll(); model.addAttribute(“employeeList”, employeeList);

return “employee_list”;

}

<!DOCTYPE html>